6.Gün - Swift Loops (Döngüler)

Bilgisayarlar tekrarlayan işlemleri gerçekleştirmekte oldukça başaralıdırlar. Swift’te bu tekrarlı yapılar loop (döngü) olarak adlandırılmaktadır. Swift’te kullanılan iki adet döngü bulunmaktadır ; for ve while döngüsü.

for Döngüsü #

Elimizde bir adet String Array’i olduğunu varsayalım. Bu Array’in her bir öğesini tek tek terminale yazdırma için aşağıdaki gibi bir kod yazabiliriz.

let platforms = ["iOS", "macOS", "tvOS", "watchOS"]

for os in platforms {
    print("Swift works great on \(os).")
}

//ÇIKTI:
//----------------------------------------
// Swift works great on iOS.
// Swift works great on macOS.
// Swift works great on tvOS.
// Swift works great on watchOS.

Bu, platform Array’i üzerinde bir döngü yaparak, her bir öğeyi teker teker os içerisine yerleştirir. os değişkenini başka bir yerde oluşturmadık, döngünün bir parçasıdır ve sadece döngü parantezleri içinde kullanılabilir.

Array’deki her bir öğe için çalıştırmak istediğimiz kod, { } parantezleri içine yazılmıştır. Bu sebeple ekrana dört satır yazı yazılır.

Döngülerde kullanılan genel isimlendirme şu şekildedir.

• Loop Body : Döngü Gövdesi. { } parantezleri içindeki koda denir.
• Loop Iteration : Döngü Yinelemesi. Döngü boyunca yapılan, 1 döngüye denir.
• Loop Variable : Döngü Değişkeni. Döngü gövdesi boyunca var olur ve her bir döngü yinilemesinde değeri değişir.

Bir Array yerine (veya Set, veya Dictionary), sabit bir sayı aralığında da döngü yapabiliriz.

for i in 1...12 {
    print("5 x \(i) is \(5 * i)")
}

//ÇIKTI:
//----------------------------------------
// 5 x 1 is 5
// 5 x 2 is 10
// 5 x 3 is 15
// 5 x 4 is 20
// 5 x 5 is 25
// 5 x 6 is 30
// 5 x 7 is 35
// 5 x 8 is 40
// 5 x 9 is 45
// 5 x 10 is 50
// 5 x 11 is 55
// 5 x 12 is 60

Bu noktada değinmemiz gereken bazı şeyler var;

• Sabit aralıklı döngülerde yaygın bir kural olarak, döngü değişkeni olarak i kullanılır. Eğer ikinci bir sayı daha varsa j , üçüncü bir sayı içinse k kullanılır. Dördüncü bir sayımız varsa daha iyi bir isimlendirme seçmeliyiz. 😊
• 1…12 kısmı range olarak adlandırılmaktadır. Anlamı; “1 ve 12 dahil olmak üzere 1 ve 12 nin arasındaki tüm tam sayılardır.” Range Swift’e özgü bir veri tipidir.

for i in 1...12 {
    print("The \(i) times table:")

    for j in 1...12 {
        print("  \(j) x \(i) is \(j * i)")
    }

    print()
}

//ÇIKTI:
//----------------------------------------
//The 1 times table:
//  1 x 1 is 1
//  2 x 1 is 2
//  3 x 1 is 3
//  4 x 1 is 4
//  5 x 1 is 5
//  6 x 1 is 6
//  7 x 1 is 7
//  8 x 1 is 8
//  9 x 1 is 9
//  10 x 1 is 10
//  11 x 1 is 11
//  12 x 1 is 12

//The 2 times table:
//.
//.
//.
//Bu çıktı oldukça uzun, kendi Xcode Playground'ınızda denemeniz daha iyi olur.

Burada iç içe bir döngü var ( nested loop ) 1’den 12’ye kadar sayıyoruz ve içindeki her sayıyı tekrar 1’den 12’ye kadar sayıyoruz.

Swift Range (x…y) #

x…y gördüğümüzde şunu anlamalıyız: x kaçsa ondan başlayan ve y sayısı kaçsa ona (dahil) kadar devam eden bir aralık anlamalıyız.

Swift’te son sayıya kadar sayan fakat son sayıyı hariç tutan bir Range daha vardır. ..<5

for i in 1...5 {
    print("Counting from 1 through 5: \(i)")
}

print()

for i in 1..<5 {
    print("Counting 1 up to 5: \(i)")
}

//ÇIKTI:
//----------------------------------------
// Counting from 1 through 5: 1
// Counting from 1 through 5: 2
// Counting from 1 through 5: 3
// Counting from 1 through 5: 4
// Counting from 1 through 5: 5

// Counting 1 up to 5: 1
// Counting 1 up to 5: 2
// Counting 1 up to 5: 3
// Counting 1 up to 5: 4

Bazen, bir Range kullanarak bir döngü oluşturmak ve bu döngüde, döngü değişkenini kullanmak istemeyebiliriz. Böyle bir durumda döngü değişkeni yerine _ kullanırız.

var lyric = "Haters gonna"

for _ in 1...5 {
    lyric += " hate"
}

print(lyric)

//ÇIKTI:
//----------------------------------------
//Haters gonna hate hate hate hate hate

while Döngüsü #

Swift’te while adında bir döngü daha bulunmaktadır. while döngüsü kontrol ettiği koşul yanlış olana kadar çalışmaya devam edecektir.

İşte while döngüsüne bir örnek;

var countdown = 10

while countdown > 0 {
    print("\(countdown)…")
    countdown -= 1
}

print("Blast off!")

//ÇIKTI:
//----------------------------------------
// 10…
// 9…
// 8…
// 7…
// 6…
// 5…
// 4…
// 3…
// 2…
// 1…
// Blast off!

while döngüsü, döngünün ne kadar döneciğini bilmediğimiz durumlar için oldukça kullanışlıdır.

Int ve Double ’ın ikiside random(in:) isimli bir fonksiyona sahiptir. Bu fonksiyon kendisine verilen aralık dahilinde rastgele sayı üretir.

1 ve 1000 arasında rastgele sayı üretmek için;

let id = Int.random(in: 1...1000)

0 ve 1 arasında rastgele sayı üretmek için;

let amount = Double.random(in: 0...1)

while döngüsü ve random(in:) fonksiyonunu kullanarak 20 yüzlü bir zar atma oyunu yapabiliriz.

Döngü yalnızca 20 geldiğinde sonlanacaktır.

// atışımızı saklamak için bir integer oluşturalım
var roll = 0

// 20 sayısına ulaşana kadar döngü devam etsin
while roll != 20 {
    // yeni bir zar at ve ne olduğunu yazdır
    roll = Int.random(in: 1...20)
    print("I rolled a \(roll)")
}

// eğer buradaysak döngü sona erdi demektir. 20 puan alındı.   
print("Critical hit!")

for döngüleri, bir aralık veya bir Array gibi sınırlı bir veri olduğunda oldukça kullanışlıdır. while döngüleri ise özel bir koşula ihtiyacımız olduğunda yararlıdırlar.

break ve continue #

Swift, bize bir döngüdeki bir veya daha fazla öğeyi atlamak için iki yol sunar: continue o anda işletilen döngü yinelemesini (iteration) atlamamızı, break ise döngüdeki geriye kalan bütün yinelemeleri (iteration) atlamamızı sağlar.

continue #

Örneğin, bir Array içerisinde bulunan dosya isimlerinden, uzantısı “.jpg” olanı terminale yazdırmak isteyelim;

let filenames = ["me.jpg", "work.txt", "sophie.jpg", "logo.psd"]

for filename in filenames {
    if filename.hasSuffix(".jpg") == false {
        continue
    }

    print("Found picture: \(filename)")
}

//ÇIKTI:
//----------------------------------------
// Found picture: me.jpg
// Found picture: sophie.jpg

Bir String Array’i oluşturulur. Ardından her bir String alınır ve “.jpg” uzantısına sahip olup olmadığı kontrol edilir. continue ”.jpg” uzantısına sahip olmayan her bir String için devreye girerek, döngü yinelemesini atlar.

break #

break ise döngüden hemen çıkar ve kalan tüm yinelemeleri atlar. Aşağıdaki örneği inceleyelim;

let number1 = 4
let number2 = 14
var multiples = [Int]()

for i in 1...100_000 {
    if i.isMultiple(of: number1) && i.isMultiple(of: number2) {
        multiples.append(i)

        if multiples.count == 10 {
            break
        }
    }
}

print(multiples)
//ÇIKTI:
//----------------------------------------
// [28, 56, 84, 112, 140, 168, 196, 224, 252, 280]

Bu örnekte ne yapıldığını inceleyelim;

1. İki sayıyı tutmak için, iki adet sabit oluşturulur.
2. İki sayının ortak katlarını saklayacak bir Array oluşturulur.
3. Döngü değişkeni i ye değer atanacak şekilde, 1’den 100,000’e kadar sayılır.
4. Eğer i hem birinci hem de ikinci sayının katıysa, multiplies Array’ine eklenir.
5. 10 tane ortak kata ulaşınca döngüden çıkmak için break kullanılır.
6. multiplies Array’i terminal ekranına yazdırılır.

Swift Etiketli İfadeler (Labeled Statements) #

Swift’te etiketli ifadeler, kodumuzun belirli bölümlerini adlandırmamıza olanak tanır ve genellikle iç içe döngülerden (nested loop) çıkmak için kullanılır.

Kilitli bir kasamız olduğunu varsayalım. Bu kasanın kilidi belirli bir kombinasyon ile açılabiliyor.

Yapabileceğimiz hareketler şu şekilde;

let options = ["up", "down", "left", "right"]

Kasanın gizli kombinasyonu ise şu;

let secretCombination = ["up", "up", "right"]

Elimizdeki hareket opsiyonları ile bu kasanın kombinasyonunu bulmaya çalışalım;

outerLoop: for option1 in options {
    for option2 in options {
        for option3 in options {
            print("In loop")
            let attempt = [option1, option2, option3]

            if attempt == secretCombination {
                print("The combination is \(attempt)!")
                break outerLoop
            }
        }
    }
}
//ÇIKTI:
//----------------------------------------
// In loop
// In loop
// In loop
// In loop
// The combination is ["up", "up", "right"]!

Eğer yukarıdaki kodda outerloop etiketini ve break kullanmasaydık, gizli kombinasyonu bulmamıza rağmen döngüler çalışmaya devam edecekti.

break kullanmamıza rağmen outerloop etiketini kullanmasaydık da, loop3’ten çıkacaktık fakat diğer iki döngüde kalmaya devam edecektik.

outlerloop ve break ‘i beraber kullanarak Swift’e şunu diyoruz: “Gizli kombinasyon bulunur bulunmaz tüm döngülerden çık.”

Bu yazıyı İngilizce olarak da okuyabilirsiniz.
You can also read this article in English.